home *** CD-ROM | disk | FTP | other *** search
/ E.M.Computergraphic Phase 1 / Phase 1 - EMC Computergraphic.iso / utilities / forceicon / source / ficonprefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-19  |  60.2 KB  |  2,467 lines
  1. /*
  2. Auto:        smake FIconPrefs
  3. */
  4.  
  5.  
  6. /* $Revision Header built automatically *************** (do not edit) ************
  7. **
  8. ** © Copyright by GuntherSoft
  9. **
  10. ** File             : SnakeSYS:CPrgs/ForceIcon2/FIconPrefs.c
  11. ** Created on       : Wednesday, 16.03.94 16:19:51
  12. ** Created by       : Kai Iske
  13. ** Current revision : V1.0
  14. **
  15. **
  16. ** Purpose
  17. ** -------
  18. **   - Prefs Editor for ForceIcon
  19. **
  20. ** Revision V1.0
  21. ** --------------
  22. ** created on Wednesday, 16.03.94 16:19:51  by  Kai Iske.   LogMessage :
  23. **     --- Initial release ---
  24. **
  25. *********************************************************************************/
  26.  
  27.  
  28.  
  29.  
  30. /**********************************************************************/
  31. /*                     Define for DisplayError()                      */
  32. /**********************************************************************/
  33. #define    PREFSRUN
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40. /**********************************************************************/
  41. /*                      Routines for this module                      */
  42. /**********************************************************************/
  43. static BOOL            OpenAll(void);
  44. static void            CloseAll(void);
  45. static struct    FIconSema    *FindFIconSema(void);
  46. static void            RemoveFIconSema(struct FIconSema *FIconSema);
  47. static BOOL            InitApp(void);
  48. static void            RemoveApp(void);
  49. static ULONG    __saveds __asm    DispViewFunc(register __a0 struct Hook *MyHook, register __a2 char **array, register __a1 struct VolEntry *Data);
  50. static ULONG    __saveds __asm    DisableFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data);
  51. static ULONG    __saveds __asm    PageChangeFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data);
  52. static struct    VolEntry    *AddNewVolume(char *Name, ULONG Type, struct VolEntry *CopyPtr);
  53. static BOOL            CheckExists(char *Name);
  54. static BOOL            SavePrefs(BOOL EnvMode);
  55. static void            DskChange(struct VolEntry *ListEntry);
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62. /**********************************************************************/
  63. /*                    Functions of files included                     */
  64. /**********************************************************************/
  65.     // LoadPrefs.h
  66.  
  67. static void            LoadPrefs(struct FIconSema *FIconSema);
  68.  
  69.     // VolList.h
  70.  
  71. static BOOL            GetDevVolList(struct List *VolList);
  72. static BOOL            GetDosEntries(struct List *VolList, ULONG Mode);
  73. static void            FreeDevVolList(struct List *VolList);
  74. static void            SortList(struct List *VolList, BOOL DisplayType);
  75. static void            SortPartialList(struct List *VolList, UWORD Left, UWORD Right);
  76. static APTR            GetListEntry(struct List *List, WORD EntryNum);
  77. static BOOL            MyStrCmp(char *FromName, char *ToName);
  78.  
  79.     // Error.h
  80.  
  81. static void    __stdargs    DisplayError(LONG ErrCode, ULONG Arg1, ...);
  82.  
  83.     // CheckToolTypes.h
  84.  
  85. static void            CheckToolTypes(struct WBStartup *WBenchMsg);
  86.  
  87.     // PoolVec.h
  88.  
  89. static APTR            AllocVecPool(struct FIconSema *FIconSema, ULONG Size);
  90. static void            FreeVecPool(struct FIconSema *FIconSema, APTR Addr);
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97. /**********************************************************************/
  98. /*                           Library bases                            */
  99. /**********************************************************************/
  100. struct    ExecBase        *SysBase;
  101. struct    IntuitionBase        *IntuitionBase    = NULL;
  102. struct    DosLibrary        *DOSBase    = NULL;
  103. struct    Library            *IconBase    = NULL;
  104. struct    Library            *UtilityBase    = NULL;
  105. struct    Library            *IFFParseBase    = NULL;
  106. struct    Library            *MUIMasterBase    = NULL;
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113. /**********************************************************************/
  114. /*                         "No-StartUp vars"                          */
  115. /**********************************************************************/
  116. #define    MUIVERS                    "$VER:ForceIcon_Prefs "REVISION" ("REVDATE")"
  117. char                _ProgramName[]    = "ForceIconPrefs";
  118. LONG                _OSERR        = 0;
  119.  
  120.  
  121.  
  122.  
  123. /**********************************************************************/
  124. /*                           Our variables                            */
  125. /**********************************************************************/
  126. static    struct    FIconSema    *FIconSema    = NULL;        // Pointer to our rendezvous semaphore
  127. static    struct    List        AvailableList;
  128. static    UWORD            FlushMemory    = FALSE;
  129.  
  130.  
  131.  
  132.  
  133. /**********************************************************************/
  134. /*                 Application and window definitions                 */
  135. /**********************************************************************/
  136. static    struct    DiskObject    *DObj        = NULL;
  137. static    APTR            AppObject    = NULL;
  138. static    APTR            MainWindow    = NULL;
  139. static    APTR            UsedList;
  140. static    APTR            EditEntry;
  141. static    APTR            CopyEntry;
  142. static    APTR            RemoveEntry;
  143. static    APTR            AvailList;
  144. static    APTR            AddEntry;
  145. static    APTR            AddEntryMan;
  146. static    APTR            RescanList;
  147. static    APTR            SaveObj;
  148. static    APTR            UseObj;
  149. static    APTR            AboutObj;
  150. static    APTR            HideObj;
  151. static    APTR            QuitObj;
  152.  
  153. static    APTR            EditWindow;
  154. static    APTR            VolumeName;
  155. static    APTR            VolumeType;
  156. static    APTR            IconPosGroup;
  157. static    APTR            IconPos[2];
  158. static    APTR            IconX;
  159. static    APTR            IconY;
  160. static    APTR            Position;
  161. static    APTR            UseIconGroup;
  162. static    APTR            UseIcon[2];
  163. static    APTR            IconName;
  164. static    APTR            UseWindowGroup;
  165. static    APTR            UseWindow[2];
  166. static    APTR            WinX;
  167. static    APTR            WinY;
  168. static    APTR            WinWidth;
  169. static    APTR            WinHeight;
  170. static    APTR            LookWin;
  171. static    APTR            UseFlagsGroup;
  172. static    APTR            UseFlags[2];
  173. static    APTR            FlagModes;
  174. static    APTR            EditOkObj;
  175. static    APTR            EditCancelObj;
  176.  
  177. static    APTR            ManWindow;
  178. static    APTR            ManVolName;
  179. static    APTR            ManVolType;
  180. static    APTR            ManOkObj;
  181. static    APTR            ManCancelObj;
  182.  
  183.  
  184.  
  185.  
  186.  
  187. /**********************************************************************/
  188. /*                     Strings for Cycle gadgets                      */
  189. /**********************************************************************/
  190. static const char *TypeEntries[] =
  191. {
  192.     "Volume",
  193.     "Device",
  194.     NULL
  195. };
  196.  
  197.  
  198. static const char *ModeEntriesVol[] =
  199. {
  200.     "Ignore",
  201.     "Use",
  202.     "Inherit",
  203.     NULL
  204. };
  205.  
  206.  
  207. static const char *ModeEntriesDev[] =
  208. {
  209.     "Ignore",
  210.     "Use",
  211.     NULL
  212. };
  213.  
  214.  
  215. static const char *PositionEntries[] =
  216. {
  217.     "Open position window",
  218.     "Close position window",
  219.     NULL
  220. };
  221.  
  222.  
  223.  
  224. static const char *LookWinEntries[] =
  225. {
  226.     "Open window",
  227.     "Close window",
  228.     NULL
  229. };
  230.  
  231.  
  232. static const char *FlagModesEntries[] =
  233. {
  234.     "only icons + view by icon",
  235.     "only icons + view by name",
  236.     "only icons + view by date",
  237.     "only icons + view by size",
  238.     "all files + view by icon",
  239.     "all files + view by name",
  240.     "all files + view by date",
  241.     "all files + view by size",
  242.     NULL
  243. };
  244.  
  245.  
  246. /**********************************************************************/
  247. /*                            Display Hook                            */
  248. /**********************************************************************/
  249. static struct Hook    DispViewHook =
  250. {
  251.     {NULL},
  252.     (APTR)DispViewFunc,
  253.     NULL,
  254.     NULL
  255. };
  256.  
  257.  
  258.  
  259. static struct Hook    DisableHook =
  260. {
  261.     {NULL},
  262.     (APTR)DisableFunc,
  263.     NULL,
  264.     NULL
  265. };
  266.  
  267.  
  268.  
  269. static struct Hook    PageChangeHook =
  270. {
  271.     {NULL},
  272.     (APTR)PageChangeFunc,
  273.     NULL,
  274.     NULL
  275. };
  276.  
  277.  
  278.  
  279. /**********************************************************************/
  280. /*                      This is our main program                      */
  281. /**********************************************************************/
  282. ULONG __saveds main(void)
  283. {
  284.     struct    Process        *MyProc;
  285.     struct    WBStartup    *WBenchMsg    = NULL;
  286.     struct    VolEntry    *EditEntryPtr    = NULL;
  287.     struct    Window        *PosWindow    = NULL,
  288.                 *DrawerWindow    = NULL;
  289.     ULONG            MySig,
  290.                 ReturnID;
  291.     BOOL            GoOn        = TRUE;
  292.  
  293.  
  294.  
  295.  
  296.         // Get SysBase
  297.  
  298.     SysBase    = *((struct ExecBase **)0x4L);
  299.  
  300.  
  301.         // Get address of our process
  302.  
  303.     MyProc = (struct Process *)FindTask(NULL);
  304.  
  305.  
  306.  
  307.         // Determine where we were started from
  308.  
  309.     if(!MyProc->pr_CLI)
  310.     {
  311.         WaitPort(&MyProc->pr_MsgPort);
  312.         WBenchMsg = (struct WBStartup *)GetMsg(&MyProc->pr_MsgPort);
  313.     }
  314.  
  315.  
  316.  
  317.         // Don`t run under OS < 37
  318.  
  319.     if(((struct Library *)SysBase)->lib_Version >= 37)
  320.     {
  321.             // Open libraries
  322.  
  323.         if(OpenAll())
  324.         {
  325.             if((FIconSema = FindFIconSema()))
  326.             {
  327.                     // Check for ToolTypes/commandline options
  328.  
  329.                 CheckToolTypes(WBenchMsg);
  330.  
  331.                 if(InitApp())
  332.                 {
  333.                     while(GoOn)
  334.                     {
  335.                         switch(ReturnID = DoMethod(AppObject, MUIM_Application_Input, &MySig))
  336.                         {
  337.                                 // Handle MAINWINDOW
  338.  
  339.  
  340.                                 // Save ?!?!
  341.  
  342.                             case ID_SAVE :
  343.                             {
  344.                                 SavePrefs(FALSE);
  345.                                 GoOn    = FALSE;
  346.                                 break;
  347.                             }
  348.  
  349.                                 // Use ?!?!
  350.  
  351.                             case ID_USE :
  352.                             {
  353.                                 SavePrefs(TRUE);
  354.                                 GoOn    = FALSE;
  355.                                 break;
  356.                             }
  357.  
  358.                                 // About ???
  359.  
  360.                             case ID_ABOUT :
  361.                             {
  362.                                 DisplayError(ERR_ABOUT, VERNUM, REVNUM, REVDATE, NULL);
  363.                                 break;
  364.                             }
  365.  
  366.                                 // Hide/Quit Prefs ?!?
  367.  
  368.                             case ID_HIDE :
  369.                             {
  370.                                 GoOn    = FALSE;
  371.                                 break;
  372.                             }
  373.  
  374.                                 // Hide/Quit Prefs and server ???
  375.  
  376.                             case ID_QUIT :
  377.                             {
  378.                                 struct    Task    *ServerTask;
  379.  
  380.                                 ObtainSemaphore(&FIconSema->FIconSema);
  381.                                 Forbid();
  382.                                 ServerTask    = FIconSema->ServerTask;
  383.                                 ReleaseSemaphore(&FIconSema->FIconSema);
  384.  
  385.                                     // Tell server to go away
  386.  
  387.                                 if(ServerTask)
  388.                                     Signal(ServerTask, SIGBREAKF_CTRL_C);
  389.                                 Permit();
  390.  
  391.                                 GoOn    = FALSE;
  392.                                 break;
  393.                             }
  394.  
  395.                             case ID_USEDLIST :
  396.                             case ID_EDITENTRY :
  397.                             {
  398.                                 struct    VolEntry    *ThisEntry;
  399.  
  400.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  401.  
  402.                                 if(ThisEntry)
  403.                                 {
  404.                                     set(VolumeName, MUIA_String_Contents, ThisEntry->VolName);
  405.                                     set(VolumeType, MUIA_Cycle_Active, (ThisEntry->Link.ln_Type == LDF_DEVICES));
  406.                                     set(IconPos[0], MUIA_Cycle_Active, ThisEntry->IconPos);
  407.                                     set(IconPos[1], MUIA_Cycle_Active, ThisEntry->IconPos);
  408.                                     set(IconX, MUIA_String_Integer, ThisEntry->Left);
  409.                                     set(IconX, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  410.                                     set(IconY, MUIA_String_Integer, ThisEntry->Top);
  411.                                     set(IconY, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  412.                                     set(Position, MUIA_Cycle_Active, 0);
  413.                                     set(Position, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  414.                                     set(UseIcon[0], MUIA_Cycle_Active, ThisEntry->UseAlt);
  415.                                     set(UseIcon[1], MUIA_Cycle_Active, ThisEntry->UseAlt);
  416.                                     set(IconName, MUIA_String_Contents, ThisEntry->IconName);
  417.                                     set(IconName, MUIA_Disabled, (ThisEntry->UseAlt != MODE_USE));
  418.                                     set(UseWindow[0], MUIA_Cycle_Active, ThisEntry->UseWin);
  419.                                     set(UseWindow[1], MUIA_Cycle_Active, ThisEntry->UseWin);
  420.                                     set(WinX, MUIA_String_Integer, ThisEntry->WinX);
  421.                                     set(WinX, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  422.                                     set(WinY, MUIA_String_Integer, ThisEntry->WinY);
  423.                                     set(WinY, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  424.                                     set(WinWidth, MUIA_String_Integer, ThisEntry->WinWidth);
  425.                                     set(WinWidth, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  426.                                     set(WinHeight, MUIA_String_Integer, ThisEntry->WinHeight);
  427.                                     set(WinHeight, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  428.                                     set(LookWin, MUIA_Cycle_Active, 0);
  429.                                     set(LookWin, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  430.                                     set(UseFlags[0], MUIA_Cycle_Active, ThisEntry->UseFlags);
  431.                                     set(UseFlags[1], MUIA_Cycle_Active, ThisEntry->UseFlags);
  432.                                     set(FlagModes, MUIA_Cycle_Active, ThisEntry->WinFlags);
  433.                                     set(FlagModes, MUIA_Disabled, (ThisEntry->UseFlags != MODE_USE));
  434.  
  435.                                     set(MainWindow, MUIA_Window_Sleep, TRUE);
  436.  
  437.                                     set(EditWindow, MUIA_Window_Open, TRUE);
  438.  
  439.                                     EditEntryPtr    = ThisEntry;
  440.                                 }
  441.                                 break;
  442.                             }
  443.  
  444.                                 // Copy an entry ???
  445.  
  446.                             case ID_COPYENTRY :
  447.                             {
  448.                                 struct    VolEntry    *ThisEntry;
  449.  
  450.  
  451.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  452.  
  453.                                 if(ThisEntry)
  454.                                 {
  455.                                     set(ManVolName, MUIA_String_Contents, ThisEntry->VolName);
  456.                                     set(ManVolType, MUIA_Cycle_Active, (ThisEntry->Link.ln_Type == LDF_DEVICES));
  457.  
  458.                                     set(MainWindow, MUIA_Window_Sleep, TRUE);
  459.                                     set(ManWindow, MUIA_Window_Title, "Copy entry");
  460.                                     set(ManWindow, MUIA_Window_Open, TRUE);
  461.  
  462.                                     EditEntryPtr    = ThisEntry;
  463.                                 }
  464.                                 break;
  465.                             }
  466.  
  467.  
  468.                                 // Remove an entry ???
  469.  
  470.                             case ID_REMOVEENTRY :
  471.                             {
  472.                                 struct    VolEntry    *ThisEntry;
  473.  
  474.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  475.  
  476.                                 if(ThisEntry)
  477.                                 {
  478.                                     ObtainSemaphore(&FIconSema->FIconSema);
  479.  
  480.                                         // Remove entry from listview
  481.  
  482.                                     DoMethod(UsedList, MUIM_List_Remove, MUIV_List_Remove_Active);
  483.  
  484.                                         // Remove entry from internal list
  485.  
  486.                                     Remove(ThisEntry);
  487.                                     FreeVecPool(FIconSema, ThisEntry);
  488.  
  489.                                     FIconSema->VolumeList.lh_Type--;
  490.  
  491.                                     ReleaseSemaphore(&FIconSema->FIconSema);
  492.                                 }
  493.                                 break;
  494.                             }
  495.  
  496.                                 // Add an entry ???
  497.  
  498.                             case ID_AVAILLIST :
  499.                             case ID_ADDENTRY :
  500.                             {
  501.                                 struct    VolEntry    *ThisEntry;
  502.  
  503.                                     // Really get entry ???
  504.  
  505.                                 DoMethod(AvailList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  506.  
  507.                                 if(ThisEntry)
  508.                                     AddNewVolume(ThisEntry->VolName, ThisEntry->Link.ln_Type, NULL);
  509.                                 break;
  510.                             }
  511.  
  512.  
  513.                                 // Manually add an entry ???
  514.  
  515.                             case ID_ADDENTRYMAN :
  516.                             {
  517.                                 set(ManVolName, MUIA_String_Contents, "");
  518.                                 set(ManVolType, MUIA_Cycle_Active, 0);
  519.  
  520.                                 set(MainWindow, MUIA_Window_Sleep, TRUE);
  521.                                 set(ManWindow, MUIA_Window_Title, "Add manually");
  522.                                 set(ManWindow, MUIA_Window_Open, TRUE);
  523.  
  524.                                 EditEntryPtr    = NULL;
  525.                                 break;
  526.                             }
  527.  
  528.  
  529.                                 // Rescan list ???
  530.  
  531.                             case ID_RESCANLIST :
  532.                             {
  533.                                 struct    VolEntry    *ThisEntry;
  534.  
  535.  
  536.                                     // Remove List from listview
  537.  
  538.                                 DoMethod(AvailList, MUIM_List_Clear, NULL);
  539.  
  540.                                     // FreeList
  541.  
  542.                                 FreeDevVolList(&AvailableList);
  543.                                 GetDevVolList(&AvailableList);
  544.  
  545.                                     // Add list of available entries
  546.  
  547.                                 ThisEntry    = (struct VolEntry *)AvailableList.lh_Head;
  548.                                 while(ThisEntry->Link.ln_Succ)
  549.                                 {
  550.                                     DoMethod(AvailList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  551.  
  552.                                     ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  553.                                 }
  554.                                 break;
  555.                             }
  556.  
  557.  
  558.  
  559.                                 // Check Edit window
  560.  
  561.  
  562.                                 // New input from IconX/Y gadgets?
  563.  
  564.                             case ID_ICONX :
  565.                             case ID_ICONY :
  566.                             {
  567.                                 ULONG    PosX,
  568.                                     PosY;
  569.  
  570.  
  571.                                     // Only do, when PosWindow is open, as values
  572.                                     // will be obtained on exit, anyway
  573.  
  574.                                 if(PosWindow)
  575.                                 {
  576.                                     get(IconX, MUIA_String_Integer, &PosX);
  577.                                     get(IconY, MUIA_String_Integer, &PosY);
  578.  
  579.                                     ChangeWindowBox(PosWindow, PosX, PosY, PosWindow->Width, PosWindow->Height);
  580.                                 }
  581.                                 break;
  582.                             }
  583.                             
  584.                                 // New input from Drawer Windows?
  585.  
  586.                             case ID_WINX :
  587.                             case ID_WINY :
  588.                             case ID_WINWIDTH :
  589.                             case ID_WINHEIGHT :
  590.                             {
  591.                                 ULONG    Left,
  592.                                     Top,
  593.                                     Width,
  594.                                     Height;
  595.  
  596.                                 if(DrawerWindow)
  597.                                 {
  598.                                     get(WinX, MUIA_String_Integer, &Left);
  599.                                     get(WinY, MUIA_String_Integer, &Top);
  600.                                     get(WinWidth, MUIA_String_Integer, &Width);
  601.                                     get(WinHeight, MUIA_String_Integer, &Height);
  602.  
  603.                                     ChangeWindowBox(DrawerWindow, Left, Top, Width, Height);
  604.                                 }
  605.                                 break;
  606.                             }
  607.  
  608.  
  609.                                 // Open/Close position window ???
  610.  
  611.                             case ID_POSITION :
  612.                             {
  613.                                 ULONG    State;
  614.  
  615.                                 get(Position, MUIA_Cycle_Active, &State);
  616.  
  617.                                 if(State && !PosWindow && EditEntryPtr)
  618.                                 {
  619.                                     struct    Screen    *WBScreen;
  620.                                     ULONG        Left,
  621.                                             Top;
  622.  
  623.                                     get(IconX, MUIA_String_Integer, &Left);
  624.                                     get(IconY, MUIA_String_Integer, &Top);
  625.  
  626.                                     if((WBScreen = LockPubScreen(NULL)))
  627.                                     {
  628.                                         PosWindow = OpenWindowTags(NULL,
  629.                                                 WA_Left,    Left,
  630.                                                 WA_Top,        Top,
  631.                                                 WA_Width,    (WBScreen->BarLayer->rp->Font->tf_XSize * 8) + 30 + WBScreen->WBorLeft + WBScreen->WBorRight,
  632.                                                 WA_Height,    WBScreen->WBorTop + WBScreen->Font->ta_YSize + 1,
  633.                                                 WA_IDCMP,    IDCMP_CHANGEWINDOW,
  634.                                                 WA_Flags,    WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_RMBTRAP,
  635.                                                 WA_Title,    "IconPos",
  636.                                                 WA_PubScreen,    WBScreen,
  637.                                         TAG_DONE);
  638.  
  639.                                         UnlockPubScreen(NULL, WBScreen);
  640.  
  641.                                         if(!PosWindow)
  642.                                         {
  643.                                             set(Position, MUIA_Cycle_Active, 0);
  644.                                             DisplayError(ERR_NOMEM, NULL);
  645.                                         }
  646.                                     }
  647.                                 }
  648.                                 else if(PosWindow)
  649.                                 {
  650.                                     CloseWindow(PosWindow);
  651.                                     PosWindow    = NULL;
  652.                                 }
  653.                                 break;
  654.                             }
  655.  
  656.                                 // Open/Close Drawer Window ???
  657.  
  658.                             case ID_DRAWER :
  659.                             {
  660.                                 ULONG    State;
  661.  
  662.                                 get(LookWin, MUIA_Cycle_Active, &State);
  663.  
  664.                                 if(State && !DrawerWindow && EditEntryPtr)
  665.                                 {
  666.                                     struct    Screen    *WBScreen;
  667.                                     ULONG        Left,
  668.                                             Top,
  669.                                             Width,
  670.                                             Height;
  671.  
  672.  
  673.                                     get(WinX, MUIA_String_Integer, &Left);
  674.                                     get(WinY, MUIA_String_Integer, &Top);
  675.                                     get(WinWidth, MUIA_String_Integer, &Width);
  676.                                     get(WinHeight, MUIA_String_Integer, &Height);
  677.  
  678.                                     if((WBScreen = LockPubScreen(NULL)))
  679.                                     {
  680.                                         DrawerWindow = OpenWindowTags(NULL,
  681.                                                 WA_Left,    Left,
  682.                                                 WA_Top,        Top,
  683.                                                 WA_Width,    (Width ? Width: 50),
  684.                                                 WA_Height,    (Height ? Height : 50),
  685.                                                 WA_MaxWidth,    -1,
  686.                                                 WA_MaxHeight,    -1,
  687.                                                 WA_IDCMP,    IDCMP_CHANGEWINDOW,
  688.                                                 WA_Flags,    WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_RMBTRAP|WFLG_SIZEBRIGHT|WFLG_SIZEBBOTTOM,
  689.                                                 WA_Title,    "Drawer window (demo)",
  690.                                                 WA_PubScreen,    WBScreen,
  691.                                                 WA_SizeGadget,    TRUE,
  692.                                         TAG_DONE);
  693.  
  694.                                         UnlockPubScreen(NULL, WBScreen);
  695.                                         
  696.                                         if(!DrawerWindow)
  697.                                         {
  698.                                             set(LookWin, MUIA_Cycle_Active, 0);
  699.                                             DisplayError(ERR_NOMEM, NULL);
  700.                                         }
  701.                                     }
  702.                                 }
  703.                                 else if(DrawerWindow)
  704.                                 {
  705.                                     CloseWindow(DrawerWindow);
  706.                                     DrawerWindow    = NULL;
  707.                                 }
  708.                                 break;
  709.                             }
  710.  
  711.                                 // Ok ???
  712.  
  713.                             case ID_EDITOK :
  714.                             {
  715.                                 ULONG    OldType,
  716.                                     NewName,
  717.                                     PopAslState;
  718.                                 BOOL    DoSort    = FALSE;
  719.  
  720.  
  721.                                     // Don`t close window, when FileRequester is open
  722.  
  723.                                 get(IconName, MUIA_Popasl_Active, &PopAslState);
  724.                                 if(!PopAslState)
  725.                                 {
  726.                                     set(EditWindow, MUIA_Window_Open, FALSE);
  727.                                     if(PosWindow)
  728.                                     {
  729.                                         CloseWindow(PosWindow);
  730.                                         PosWindow    = NULL;
  731.                                     }
  732.                                     if(DrawerWindow)
  733.                                     {
  734.                                         CloseWindow(DrawerWindow);
  735.                                         DrawerWindow    = NULL;
  736.                                     }
  737.                                     set(MainWindow, MUIA_Window_Sleep, FALSE);
  738.  
  739.                                         // Copy contents of gadgets to selected entry
  740.  
  741.                                     if(EditEntryPtr)
  742.                                     {
  743.                                         ULONG    Dummy;
  744.  
  745.                                         ObtainSemaphore(&FIconSema->FIconSema);
  746.  
  747.                                             // Get new settings
  748.  
  749.                                         get(VolumeName, MUIA_String_Contents, &Dummy);
  750.                                         NewName = stricmp(EditEntryPtr->VolName, (char *)Dummy);
  751.                                         strcpy(EditEntryPtr->VolName, (char *)Dummy);
  752.  
  753.                                         get(VolumeType, MUIA_Cycle_Active, &Dummy);
  754.                                         OldType                = EditEntryPtr->Link.ln_Type;
  755.                                         EditEntryPtr->Link.ln_Type    = (Dummy ? LDF_DEVICES : LDF_VOLUMES);
  756.  
  757.                                         get(IconX, MUIA_String_Integer, &Dummy);
  758.                                         EditEntryPtr->Left        = Dummy;
  759.  
  760.                                         get(IconY, MUIA_String_Integer, &Dummy);
  761.                                         EditEntryPtr->Top        = Dummy;
  762.  
  763.                                         get(IconPos[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  764.                                         EditEntryPtr->IconPos    = Dummy;
  765.  
  766.                                         get(IconName, MUIA_String_Contents, &Dummy);
  767.                                         strcpy(EditEntryPtr->IconName, (char *)Dummy);
  768.  
  769.                                         get(UseIcon[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  770.                                         EditEntryPtr->UseAlt    = Dummy;
  771.  
  772.                                         get(UseWindow[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  773.                                         EditEntryPtr->UseWin    = Dummy;
  774.  
  775.                                         get(WinX, MUIA_String_Integer, &Dummy);
  776.                                         EditEntryPtr->WinX    = Dummy;
  777.  
  778.                                         get(WinY, MUIA_String_Integer, &Dummy);
  779.                                         EditEntryPtr->WinY    = Dummy;
  780.  
  781.                                         get(WinWidth, MUIA_String_Integer, &Dummy);
  782.                                         EditEntryPtr->WinWidth    = Dummy;
  783.  
  784.                                         get(WinHeight, MUIA_String_Integer, &Dummy);
  785.                                         EditEntryPtr->WinHeight    = Dummy;
  786.  
  787.                                         get(UseFlags[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  788.                                         EditEntryPtr->UseFlags    = Dummy;
  789.  
  790.                                         get(FlagModes, MUIA_Cycle_Active, &Dummy);
  791.                                         EditEntryPtr->WinFlags    = Dummy;
  792.  
  793.                                         if(!strstr(EditEntryPtr->IconName, ".info") && strlen(EditEntryPtr->IconName))
  794.                                             strcat(EditEntryPtr->IconName, ".info");
  795.  
  796.  
  797.  
  798.                                             // Type of entry changed ???
  799.  
  800.                                         if(OldType != EditEntryPtr->Link.ln_Type)
  801.                                         {
  802.                                             Remove(EditEntryPtr);
  803.  
  804.                                             if(EditEntryPtr->Link.ln_Type == LDF_DEVICES)
  805.                                                 AddTail(&FIconSema->VolumeList, (struct Node *)EditEntryPtr);
  806.                                             else
  807.                                                 AddHead(&FIconSema->VolumeList, (struct Node *)EditEntryPtr);
  808.  
  809.                                             DoSort    = TRUE;
  810.                                         }
  811.  
  812.                                             // Name changed ???
  813.  
  814.                                         if(!DoSort)
  815.                                             DoSort    = (BOOL)(NewName != 0);
  816.  
  817.                                             // Rearrange volume`s/device`s icon
  818.  
  819.                                         DskChange(EditEntryPtr);
  820.  
  821.                                             // Sort list
  822.  
  823.                                         if(DoSort)
  824.                                         {
  825.                                             SortList(&FIconSema->VolumeList, TRUE);
  826.  
  827.                                                 // Remove list
  828.  
  829.                                             DoMethod(UsedList, MUIM_List_Clear, NULL);
  830.  
  831.                                             EditEntryPtr    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  832.                                             while(EditEntryPtr->Link.ln_Succ)
  833.                                             {
  834.                                                 DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)EditEntryPtr, MUIV_List_Insert_Bottom);
  835.  
  836.                                                 EditEntryPtr    = (struct VolEntry *)EditEntryPtr->Link.ln_Succ;
  837.                                             }
  838.                                         }
  839.                                         ReleaseSemaphore(&FIconSema->FIconSema);
  840.                                     }
  841.                                     EditEntryPtr    = NULL;
  842.                                 }
  843.                                 break;
  844.                             }
  845.  
  846.                                 // Cancel ???
  847.  
  848.                             case ID_EDITCANCEL :
  849.                             {
  850.                                 ULONG    PopAslState;
  851.  
  852.                                     // Don`t close window, when FileRequester is open
  853.  
  854.                                 get(IconName, MUIA_Popasl_Active, &PopAslState);
  855.                                 if(!PopAslState)
  856.                                 {
  857.                                     set(EditWindow, MUIA_Window_Open, FALSE);
  858.                                     if(PosWindow)
  859.                                     {
  860.                                         CloseWindow(PosWindow);
  861.                                         PosWindow    = NULL;
  862.                                     }
  863.                                     if(DrawerWindow)
  864.                                     {
  865.                                         CloseWindow(DrawerWindow);
  866.                                         DrawerWindow    = NULL;
  867.                                     }
  868.                                     set(MainWindow, MUIA_Window_Sleep, FALSE);
  869.                                     EditEntryPtr    = NULL;
  870.                                 }
  871.                                 break;
  872.                             }
  873.  
  874.  
  875.  
  876.                                 // Check man window
  877.  
  878.                             case ID_MANOK :
  879.                             {
  880.                                 char            *VolName;
  881.                                 ULONG            Type;
  882.  
  883.                                 set(ManWindow, MUIA_Window_Open, FALSE);
  884.                                 set(MainWindow, MUIA_Window_Sleep, FALSE);
  885.  
  886.  
  887.                                 get(ManVolName, MUIA_String_Contents, &VolName);
  888.                                 get(ManVolType, MUIA_Cycle_Active, &Type);
  889.                                 Type    = (Type ? LDF_DEVICES : LDF_VOLUMES);
  890.  
  891.                                 AddNewVolume(VolName, Type, EditEntryPtr);
  892.                                 EditEntryPtr    = NULL;
  893.                                 break;
  894.                             }
  895.  
  896.                             case ID_MANCANCEL :
  897.                             {
  898.                                 set(ManWindow, MUIA_Window_Open, FALSE);
  899.                                 set(MainWindow, MUIA_Window_Sleep, FALSE);
  900.                                 EditEntryPtr    = NULL;
  901.                                 break;
  902.                             }
  903.                         }
  904.  
  905.  
  906.                         if(GoOn && MySig)
  907.                         {
  908.                             if(PosWindow)
  909.                                 MySig    |= (1 << PosWindow->UserPort->mp_SigBit);
  910.  
  911.                             if(DrawerWindow)
  912.                                 MySig    |= (1 << DrawerWindow->UserPort->mp_SigBit);
  913.  
  914.                             MySig    = Wait(MySig);
  915.  
  916.                                 // Check for action on PosWindow
  917.  
  918.                             if(PosWindow && (MySig & (1 << PosWindow->UserPort->mp_SigBit)))
  919.                             {
  920.                                 struct    IntuiMessage    *MyMsg;
  921.                                 ULONG    MsgClass;
  922.  
  923.                                 while((MyMsg = (struct IntuiMessage *)GetMsg(PosWindow->UserPort)))
  924.                                 {
  925.                                     MsgClass    = MyMsg->Class;
  926.  
  927.                                     ReplyMsg((struct Message *)MyMsg);
  928.  
  929.                                     if(MsgClass == IDCMP_CHANGEWINDOW)
  930.                                     {
  931.                                         set(IconX, MUIA_String_Integer, PosWindow->LeftEdge);
  932.                                         set(IconY, MUIA_String_Integer, PosWindow->TopEdge);
  933.                                     }
  934.                                 }
  935.                             }
  936.  
  937.                                 // Check for action on DrawerWindow
  938.  
  939.                             if(DrawerWindow && (MySig & (1 << DrawerWindow->UserPort->mp_SigBit)))
  940.                             {
  941.                                 struct    IntuiMessage    *MyMsg;
  942.                                 ULONG    MsgClass;
  943.  
  944.                                 while((MyMsg = (struct IntuiMessage *)GetMsg(DrawerWindow->UserPort)))
  945.                                 {
  946.                                     MsgClass    = MyMsg->Class;
  947.  
  948.                                     ReplyMsg((struct Message *)MyMsg);
  949.  
  950.                                     if(MsgClass == IDCMP_CHANGEWINDOW)
  951.                                     {
  952.                                         set(WinX, MUIA_String_Integer, DrawerWindow->LeftEdge);
  953.                                         set(WinY, MUIA_String_Integer, DrawerWindow->TopEdge);
  954.                                         set(WinWidth, MUIA_String_Integer, DrawerWindow->Width);
  955.                                         set(WinHeight, MUIA_String_Integer, DrawerWindow->Height);
  956.                                     }
  957.                                 }
  958.                             }
  959.                         }
  960.                     }
  961.  
  962.                     if(PosWindow)
  963.                         CloseWindow(PosWindow);
  964.  
  965.                         // Free list of available volumes
  966.  
  967.                     FreeDevVolList(&AvailableList);
  968.                 }
  969.  
  970.                 RemoveApp();
  971.             }
  972.  
  973.             RemoveFIconSema(FIconSema);
  974.         }
  975.     }
  976.  
  977.  
  978.         // Close libs
  979.  
  980.     CloseAll();
  981.  
  982.  
  983.         // Flush memory when requested
  984.  
  985.     if(FlushMemory)
  986.     {
  987.         APTR    FlushPtr;
  988.         int    i;
  989.  
  990.         for(i = 0; i < 10; i++)
  991.         {
  992.             if((FlushPtr = AllocMem(0x1DCD6500, MEMF_PUBLIC)))
  993.                 FreeMem(FlushPtr, 0x1DCD6500);
  994.         }
  995.     }
  996.  
  997.         // Send back WBStartUp Message
  998.  
  999.     if(WBenchMsg)
  1000.     {
  1001.         Forbid();
  1002.         ReplyMsg((struct Message *)WBenchMsg);
  1003.     }
  1004.     return(0);
  1005. }
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012. /**********************************************************************/
  1013. /*                        Functionreplacements                        */
  1014. /**********************************************************************/
  1015. void chkabort(void){;}
  1016. void __stdargs _XCEXIT(LONG Val){;}
  1017.  
  1018.  
  1019.  
  1020.  
  1021. /**********************************************************************/
  1022. /*                           Open libraries                           */
  1023. /**********************************************************************/
  1024. static BOOL OpenAll(void)
  1025. {
  1026.     if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37)))
  1027.     {
  1028.         DisplayError(ERR_OPEN, (ULONG)"intuition.library", 37);
  1029.         return(FALSE);
  1030.     }
  1031.  
  1032.     if(!(MUIMasterBase = OpenLibrary("muimaster.library", 0)))
  1033.     {
  1034.         DisplayError(ERR_OPEN, (ULONG)"muimaster.library", 7);
  1035.         return(FALSE);
  1036.     }
  1037.  
  1038.     if(!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37)))
  1039.     {
  1040.         DisplayError(ERR_OPEN, (ULONG)"dos.library", 37);
  1041.         return(FALSE);
  1042.     }
  1043.  
  1044.     if(!(IconBase = OpenLibrary("icon.library", 37)))
  1045.     {
  1046.         DisplayError(ERR_OPEN, (ULONG)"icon.library", 37);
  1047.         return(FALSE);
  1048.     }
  1049.  
  1050.     if(!(UtilityBase = OpenLibrary("utility.library", 37)))
  1051.     {
  1052.         DisplayError(ERR_OPEN, (ULONG)"utility.library", 37);
  1053.         return(FALSE);
  1054.     }
  1055.  
  1056.     if(!(IFFParseBase = OpenLibrary("iffparse.library", 37)))
  1057.     {
  1058.         DisplayError(ERR_OPEN, (ULONG)"iffparse.library", 37);
  1059.         return(FALSE);
  1060.     }
  1061.  
  1062.     if(!(AslBase = OpenLibrary("asl.library", 36)))
  1063.     {
  1064.         DisplayError(ERR_OPEN, (ULONG)"asl.library", 36);
  1065.         return(FALSE);
  1066.     }
  1067.  
  1068.     return(TRUE);
  1069. }
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078. /**********************************************************************/
  1079. /*                          Close libraries                           */
  1080. /**********************************************************************/
  1081. static void CloseAll(void)
  1082. {
  1083.     if(MUIMasterBase)
  1084.         CloseLibrary(MUIMasterBase);
  1085.  
  1086.     if(AslBase)
  1087.         CloseLibrary(AslBase);
  1088.  
  1089.     if(IFFParseBase)
  1090.         CloseLibrary(IFFParseBase);
  1091.  
  1092.     if(UtilityBase)
  1093.         CloseLibrary(UtilityBase);
  1094.  
  1095.     if(IconBase)
  1096.         CloseLibrary(IconBase);
  1097.  
  1098.     if(DOSBase)
  1099.         CloseLibrary((struct Library *)DOSBase);
  1100.  
  1101.     if(IntuitionBase)
  1102.         CloseLibrary((struct Library *)IntuitionBase);
  1103. }
  1104.  
  1105.  
  1106.  
  1107.  
  1108.  
  1109.  
  1110.  
  1111. /**********************************************************************/
  1112. /*                         Create application                         */
  1113. /**********************************************************************/
  1114. static BOOL InitApp(void)
  1115. {
  1116.         // Init list, in case the App can not be created
  1117.  
  1118.     NewList(&AvailableList);
  1119.  
  1120.         // Create the Application window
  1121.  
  1122.     AppObject    = ApplicationObject,
  1123.                 MUIA_Application_Title,        "ForceIcon",
  1124.                 MUIA_Application_Version,    MUIVERS,
  1125.                 MUIA_Application_Copyright,    "©1993/94 Kai Iske",
  1126.                 MUIA_Application_Author,    "Kai Iske",
  1127.                 MUIA_Application_Description,    "Forces Disk.info to image/position",
  1128.                 MUIA_Application_Base,        "FIcon",
  1129.                 MUIA_Application_SingleTask,    TRUE,
  1130.                 MUIA_Application_DiskObject,    DObj    = GetDiskObjectNew("PROGDIR:ForceIcon"),
  1131.                 MUIA_HelpFile,            "ForceIcon.guide",
  1132.  
  1133.             // Now head for the main window
  1134.  
  1135.         SubWindow, MainWindow =    WindowObject,
  1136.                         MUIA_Window_Title,    "ForceIcon "REVISION" - "REVDATE,
  1137.                         MUIA_Window_ID,        'FIMW',
  1138.                         MUIA_Window_SizeGadget,    TRUE,
  1139.                         MUIA_HelpNode,        NODE_MAIN,
  1140.  
  1141.                 // Do the gadgets
  1142.  
  1143.             WindowContents,
  1144.             VGroup,
  1145.  
  1146.                     // Columns of input
  1147.  
  1148.                 Child,
  1149.                 ColGroup(2),
  1150.  
  1151.                         // Create left column
  1152.  
  1153.                     Child, VGroup,
  1154.                         MUIA_HelpNode,    NODE_LEFT,
  1155.                         GroupFrameT("Used volumes/devices"),
  1156.  
  1157.  
  1158.                             // Create ListView
  1159.  
  1160.                         Child, UsedList        =    ListviewObject,
  1161.                                             MUIA_Listview_Input,        TRUE,
  1162.                                             MUIA_Listview_List,        ListObject, InputListFrame,
  1163.                                                 MUIA_Background,        MUII_ListBack,
  1164.                                                 MUIA_List_Format,        "COL=0",
  1165.                                                 MUIA_List_DisplayHook,        &DispViewHook,
  1166.                                             End,
  1167.                                         End,
  1168.  
  1169.                         Child, EditEntry    =    TextObject, ButtonFrame,
  1170.                                             MUIA_Text_Contents,    "Edit entry...",
  1171.                                             MUIA_Text_PreParse,    "\33c",
  1172.                                             MUIA_Background,    MUII_ButtonBack,
  1173.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1174.                                             MUIA_Text_HiChar,    'E',
  1175.                                             MUIA_ControlChar,    'e',
  1176.                                             MUIA_Disabled,        TRUE,
  1177.                                         End,
  1178.  
  1179.                         Child, CopyEntry    =    TextObject, ButtonFrame,
  1180.                                             MUIA_Text_Contents,    "Copy entry...",
  1181.                                             MUIA_Text_PreParse,    "\33c",
  1182.                                             MUIA_Background,    MUII_ButtonBack,
  1183.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1184.                                             MUIA_Text_HiChar,    'C',
  1185.                                             MUIA_ControlChar,    'c',
  1186.                                             MUIA_Disabled,        TRUE,
  1187.                                         End,
  1188.  
  1189.                         Child, RemoveEntry    =    TextObject, ButtonFrame,
  1190.                                             MUIA_Text_Contents,    "Remove entry",
  1191.                                             MUIA_Text_PreParse,    "\33c",
  1192.                                             MUIA_Background,    MUII_ButtonBack,
  1193.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1194.                                             MUIA_Text_HiChar,    'R',
  1195.                                             MUIA_ControlChar,    'r',
  1196.                                             MUIA_Disabled,        TRUE,
  1197.                                         End,
  1198.                     End, // First column
  1199.  
  1200.  
  1201.                         // Create right column
  1202.  
  1203.                     Child, VGroup,
  1204.                         MUIA_HelpNode,    NODE_RIGHT,
  1205.                         GroupFrameT("Available volumes/devices"),
  1206.  
  1207.                             // Create ListView
  1208.  
  1209.                         Child, AvailList    =    ListviewObject,
  1210.                                             MUIA_Listview_Input,        TRUE,
  1211.                                             MUIA_Listview_List,        ListObject, InputListFrame,
  1212.                                                 MUIA_Background,        MUII_ListBack,
  1213.                                                 MUIA_List_Format,        "COL=0",
  1214.                                                 MUIA_List_DisplayHook,        &DispViewHook,
  1215.                                             End,
  1216.                                         End,
  1217.  
  1218.                         Child, AddEntry        =    TextObject, ButtonFrame,
  1219.                                             MUIA_Text_Contents,    "Add entry",
  1220.                                             MUIA_Text_PreParse,    "\33c",
  1221.                                             MUIA_Background,    MUII_ButtonBack,
  1222.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1223.                                             MUIA_Text_HiChar,    'd',
  1224.                                             MUIA_ControlChar,    'd',
  1225.                                             MUIA_Disabled,        TRUE,
  1226.                                         End,
  1227.  
  1228.                         Child, AddEntryMan    =    TextObject, ButtonFrame,
  1229.                                             MUIA_Text_Contents,    "Add manually...",
  1230.                                             MUIA_Text_PreParse,    "\33c",
  1231.                                             MUIA_Background,    MUII_ButtonBack,
  1232.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1233.                                             MUIA_Text_HiChar,    'm',
  1234.                                             MUIA_ControlChar,    'm',
  1235.                                         End,
  1236.  
  1237.                         Child, RescanList    =    TextObject, ButtonFrame,
  1238.                                             MUIA_Text_Contents,    "Rescan list",
  1239.                                             MUIA_Text_PreParse,    "\33c",
  1240.                                             MUIA_Background,    MUII_ButtonBack,
  1241.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1242.                                             MUIA_Text_HiChar,    'l',
  1243.                                             MUIA_ControlChar,    'l',
  1244.                                         End,
  1245.                     End, // Second column
  1246.                 End, // Columns
  1247.  
  1248.  
  1249.                 Child, VSpace(1),
  1250.  
  1251.                     // Create control gadgets
  1252.  
  1253.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1254.  
  1255.                     Child, SaveObj        =    TextObject, ButtonFrame,
  1256.                                         MUIA_Text_Contents,    "Save",
  1257.                                         MUIA_Text_PreParse,    "\33c",
  1258.                                         MUIA_Background,    MUII_ButtonBack,
  1259.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1260.                                         MUIA_Text_HiChar,    'S',
  1261.                                         MUIA_ControlChar,    's',
  1262.                                     End,
  1263.  
  1264.                     Child, UseObj        =    TextObject, ButtonFrame,
  1265.                                         MUIA_Text_Contents,    "Use",
  1266.                                         MUIA_Text_PreParse,    "\33c",
  1267.                                         MUIA_Background,    MUII_ButtonBack,
  1268.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1269.                                         MUIA_Text_HiChar,    'U',
  1270.                                         MUIA_ControlChar,    'u',
  1271.                                     End,
  1272.  
  1273.                     Child, AboutObj        =    TextObject, ButtonFrame,
  1274.                                         MUIA_Text_Contents,    "About",
  1275.                                         MUIA_Text_PreParse,    "\33c",
  1276.                                         MUIA_Background,    MUII_ButtonBack,
  1277.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1278.                                         MUIA_Text_HiChar,    'A',
  1279.                                         MUIA_ControlChar,    'a',
  1280.                                     End,
  1281.  
  1282.                     Child, HideObj        =    TextObject, ButtonFrame,
  1283.                                         MUIA_Text_Contents,    "Hide",
  1284.                                         MUIA_Text_PreParse,    "\33c",
  1285.                                         MUIA_Background,    MUII_ButtonBack,
  1286.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1287.                                         MUIA_Text_HiChar,    'H',
  1288.                                         MUIA_ControlChar,    'h',
  1289.                                     End,
  1290.  
  1291.                     Child, QuitObj        =    TextObject, ButtonFrame,
  1292.                                         MUIA_Text_Contents,    "Quit",
  1293.                                         MUIA_Text_PreParse,    "\33c",
  1294.                                         MUIA_Background,    MUII_ButtonBack,
  1295.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1296.                                         MUIA_Text_HiChar,    'Q',
  1297.                                         MUIA_ControlChar,    'q',
  1298.                                     End,
  1299.                 End, // Control panel
  1300.             End, // main group
  1301.         End, // Main window
  1302.  
  1303.  
  1304.  
  1305.  
  1306.  
  1307.             // Head for Editwindow
  1308.  
  1309.         SubWindow, EditWindow = WindowObject,
  1310.                         MUIA_Window_Title,    "Edit entry",
  1311.                         MUIA_Window_ID,        'FIEW',
  1312.                         MUIA_Window_SizeGadget,    TRUE,
  1313.                         MUIA_Window_NoMenus,    TRUE,
  1314.                         MUIA_HelpNode,        NODE_EDIT,
  1315.  
  1316.             WindowContents, VGroup,
  1317.  
  1318.                     // Volume group
  1319.  
  1320.                 Child, VGroup, GroupFrameT("Entry type/name"), MUIA_Group_SameWidth, TRUE,
  1321.                     Child, ColGroup(2),
  1322.                         Child, KeyLabel1("Volume", 'V'),
  1323.                         Child, VolumeName    =    StringObject, StringFrame,
  1324.                                             MUIA_String_Contents,    "",
  1325.                                             MUIA_String_MaxLen,    128,
  1326.                                             MUIA_String_Format,    MUIV_String_Format_Left,
  1327.                                             MUIA_String_BufferPos,    0,
  1328.                                             MUIA_String_Reject,    ":/",
  1329.                                             MUIA_ControlChar,    'v',
  1330.                                         End,
  1331.  
  1332.                         Child, KeyLabel1("Type", 'e'),
  1333.                         Child, VolumeType    =    KeyCycle(TypeEntries, 'e'),
  1334.                     End,
  1335.                 End, // Volume group
  1336.  
  1337.  
  1338.                 Child, ColGroup(2),
  1339.                         // Position group
  1340.  
  1341.                     Child, VGroup, GroupFrameT("Position settings"), MUIA_Group_SameWidth, TRUE,
  1342.  
  1343.                         Child, ColGroup(2),
  1344.  
  1345.                             Child, KeyLabel1("IconPos", 's'),
  1346.                             Child, IconPosGroup = PageGroup,
  1347.  
  1348.                                 Child, IconPos[0] =    CycleObject, ButtonFrame,
  1349.                                                     MUIA_Cycle_Active,    0,
  1350.                                                     MUIA_Cycle_Entries,    ModeEntriesVol,
  1351.                                                     MUIA_ControlChar,    's',
  1352.                                             End,
  1353.  
  1354.                                 Child, IconPos[1] =    CycleObject, ButtonFrame,
  1355.                                                     MUIA_Cycle_Active,    0,
  1356.                                                     MUIA_Cycle_Entries,    ModeEntriesDev,
  1357.                                                     MUIA_ControlChar,    's',
  1358.                                             End,
  1359.                             End,
  1360.  
  1361.                             Child, KeyLabel1("Current X", 'X'),
  1362.                             Child, HGroup,
  1363.                                 Child, IconX    =    StringObject, StringFrame,
  1364.                                                 MUIA_String_Contents,    "",
  1365.                                                 MUIA_String_MaxLen,    5,
  1366.                                                 MUIA_String_Format,    MUIV_String_Format_Center,
  1367.                                                 MUIA_String_BufferPos,    1,
  1368.                                                 MUIA_String_Integer,    TRUE,
  1369.                                                 MUIA_ControlChar,    'x',
  1370.                                             End,
  1371.  
  1372.                                 Child, KeyLabel1("Current Y", 'Y'),
  1373.                                 Child, IconY    =    StringObject, StringFrame,
  1374.                                                 MUIA_String_Contents,    "",
  1375.                                                 MUIA_String_MaxLen,    5,
  1376.                                                 MUIA_String_Format,    MUIV_String_Format_Center,
  1377.                                                 MUIA_String_BufferPos,    1,
  1378.                                                 MUIA_String_Integer,    TRUE,
  1379.                                                 MUIA_ControlChar,    'y',
  1380.                                             End,
  1381.                             End,
  1382.  
  1383.                             Child, KeyLabel1("Position", 'P'),
  1384.                             Child, Position    =    CycleObject, ButtonFrame,
  1385.                                                 MUIA_Cycle_Active,    0,
  1386.                                                 MUIA_Cycle_Entries,    PositionEntries,
  1387.                                                 MUIA_ControlChar,    'p',
  1388.                                         End,
  1389.                         End,
  1390.                     End, // position group
  1391.  
  1392.  
  1393.  
  1394.                         // Icon group
  1395.  
  1396.                     Child, VGroup, GroupFrameT("Icon settings"), MUIA_Group_SameWidth, TRUE,
  1397.  
  1398.                         Child, VSpace(0),
  1399.                         Child, ColGroup(2),
  1400.  
  1401.                             Child, KeyLabel1("Use Icon", 'U'),
  1402.                             Child, UseIconGroup    = PageGroup,
  1403.  
  1404.                                 Child, UseIcon[0] =    CycleObject, ButtonFrame,
  1405.                                                     MUIA_Cycle_Active,    0,
  1406.                                                     MUIA_Cycle_Entries,    ModeEntriesVol,
  1407.                                                     MUIA_ControlChar,    'u',
  1408.                                             End,
  1409.  
  1410.                                 Child, UseIcon[1] =    CycleObject, ButtonFrame,
  1411.                                                     MUIA_Cycle_Active,    0,
  1412.                                                     MUIA_Cycle_Entries,    ModeEntriesDev,
  1413.                                                     MUIA_ControlChar,    'u',
  1414.                                             End,
  1415.                             End,
  1416.  
  1417.  
  1418.                             Child, KeyLabel1("Icon", 'I'),
  1419.                             Child, IconName            = PopaslObject,
  1420.                                                 MUIA_Popstring_String,        KeyString(0, 254, 'i'),
  1421.                                                 MUIA_Popstring_Button,        PopButton(MUII_PopFile),
  1422.                                                 MUIA_Popasl_Type,        ASL_FileRequest,
  1423.                                                 ASLFR_TitleText,        "Please select an icon...",
  1424.                                             End,
  1425.                         End,
  1426.                         Child, VSpace(0),
  1427.                     End, // Icon group
  1428.                 End,
  1429.  
  1430.                     // Create window group
  1431.  
  1432.                 Child, VGroup, GroupFrameT("Window settings"), MUIA_Group_SameWidth, TRUE,
  1433.  
  1434.                     Child, ColGroup(2),
  1435.  
  1436.                         Child, KeyLabel1("Use window", 'd'),
  1437.                         Child, UseWindowGroup    = PageGroup,
  1438.  
  1439.                             Child, UseWindow[0] =    CycleObject, ButtonFrame,
  1440.                                                 MUIA_Cycle_Active,    0,
  1441.                                                 MUIA_Cycle_Entries,    ModeEntriesVol,
  1442.                                                 MUIA_ControlChar,    'd',
  1443.                                         End,
  1444.  
  1445.                             Child, UseWindow[1] =    CycleObject, ButtonFrame,
  1446.                                                 MUIA_Cycle_Active,    0,
  1447.                                                 MUIA_Cycle_Entries,    ModeEntriesDev,
  1448.                                                 MUIA_ControlChar,    'd',
  1449.                                         End,
  1450.                         End,
  1451.  
  1452.  
  1453.                         Child, KeyLabel2("Left", 'L'),
  1454.                         Child, HGroup,
  1455.                             Child, WinX    =    StringObject, StringFrame,
  1456.                                             MUIA_String_Contents,    "",
  1457.                                             MUIA_String_MaxLen,    5,
  1458.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1459.                                             MUIA_String_BufferPos,    1,
  1460.                                             MUIA_String_Integer,    TRUE,
  1461.                                             MUIA_ControlChar,    'l',
  1462.                                         End,
  1463.  
  1464.                             Child, KeyLabel1("Top", 'T'),
  1465.                             Child, WinY    =    StringObject, StringFrame,
  1466.                                             MUIA_String_Contents,    "",
  1467.                                             MUIA_String_MaxLen,    5,
  1468.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1469.                                             MUIA_String_BufferPos,    1,
  1470.                                             MUIA_String_Integer,    TRUE,
  1471.                                             MUIA_ControlChar,    't',
  1472.                                         End,
  1473.  
  1474.                             Child, KeyLabel2("Width", 'W'),
  1475.                             Child, WinWidth    =    StringObject, StringFrame,
  1476.                                             MUIA_String_Contents,    "",
  1477.                                             MUIA_String_MaxLen,    5,
  1478.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1479.                                             MUIA_String_BufferPos,    1,
  1480.                                             MUIA_String_Integer,    TRUE,
  1481.                                             MUIA_ControlChar,    'h',
  1482.                                         End,
  1483.  
  1484.                             Child, KeyLabel1("Height", 'H'),
  1485.                             Child, WinHeight =    StringObject, StringFrame,
  1486.                                             MUIA_String_Contents,    "",
  1487.                                             MUIA_String_MaxLen,    5,
  1488.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1489.                                             MUIA_String_BufferPos,    1,
  1490.                                             MUIA_String_Integer,    TRUE,
  1491.                                             MUIA_ControlChar,    'w',
  1492.                                         End,
  1493.                         End,
  1494.  
  1495.                         Child, KeyLabel1("Window", 'n'),
  1496.                         Child, LookWin =    CycleObject, ButtonFrame,
  1497.                                             MUIA_Cycle_Active,    0,
  1498.                                             MUIA_Cycle_Entries,    LookWinEntries,
  1499.                                             MUIA_ControlChar,    'n',
  1500.                                     End,
  1501.  
  1502.  
  1503.  
  1504.                         Child, KeyLabel1("Use flags", 'f'),
  1505.                         Child, UseFlagsGroup    = PageGroup,
  1506.  
  1507.                             Child, UseFlags[0] =    CycleObject, ButtonFrame,
  1508.                                                 MUIA_Cycle_Active,    0,
  1509.                                                 MUIA_Cycle_Entries,    ModeEntriesVol,
  1510.                                                 MUIA_ControlChar,    'f',
  1511.                                         End,
  1512.  
  1513.                             Child, UseFlags[1] =    CycleObject, ButtonFrame,
  1514.                                                 MUIA_Cycle_Active,    0,
  1515.                                                 MUIA_Cycle_Entries,    ModeEntriesDev,
  1516.                                                 MUIA_ControlChar,    'f',
  1517.                                         End,
  1518.                         End,
  1519.  
  1520.                         Child, KeyLabel1("Flags", 'g'),
  1521.                         Child, FlagModes    =    CycleObject, ButtonFrame,
  1522.                                             MUIA_Cycle_Active,    0,
  1523.                                             MUIA_Cycle_Entries,    FlagModesEntries,
  1524.                                             MUIA_ControlChar,    'g',
  1525.                                     End,
  1526.                     End,
  1527.                 End, // window group
  1528.  
  1529.  
  1530.  
  1531.                 Child, VSpace(1),
  1532.  
  1533.                     // Create control gadgets
  1534.  
  1535.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1536.  
  1537.                     Child, EditOkObj    =    TextObject, ButtonFrame,
  1538.                                         MUIA_Text_Contents,    "Ok",
  1539.                                         MUIA_Text_PreParse,    "\33c",
  1540.                                         MUIA_Background,    MUII_ButtonBack,
  1541.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1542.                                         MUIA_Text_HiChar,    'O',
  1543.                                         MUIA_ControlChar,    'o',
  1544.                                     End,
  1545.  
  1546.                     Child, EditCancelObj    =    TextObject, ButtonFrame,
  1547.                                         MUIA_Text_Contents,    "Cancel",
  1548.                                         MUIA_Text_PreParse,    "\33c",
  1549.                                         MUIA_Background,    MUII_ButtonBack,
  1550.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1551.                                         MUIA_Text_HiChar,    'C',
  1552.                                         MUIA_ControlChar,    'c',
  1553.                                     End,
  1554.                 End, // Control gadgets
  1555.             End, // Edit contents
  1556.         End, // Edit window
  1557.  
  1558.  
  1559.  
  1560.  
  1561.             // Head for "manually" window
  1562.  
  1563.         SubWindow, ManWindow = WindowObject,
  1564.                         MUIA_Window_Title,    "",
  1565.                         MUIA_Window_ID,        'FINW',
  1566.                         MUIA_Window_SizeGadget,    TRUE,
  1567.                         MUIA_Window_NoMenus,    TRUE,
  1568.                         MUIA_HelpNode,        NODE_MANUAL,
  1569.  
  1570.             WindowContents, VGroup,
  1571.  
  1572.                 Child, VGroup, GroupFrameT("Entry type/name"),
  1573.  
  1574.                         // String gadget
  1575.  
  1576.                     Child, ColGroup(2),
  1577.  
  1578.                         Child, KeyLabel1("Volume", 'V'),
  1579.                         Child, ManVolName    =    StringObject, StringFrame,
  1580.                                         MUIA_String_Contents,    "",
  1581.                                         MUIA_String_MaxLen,    128,
  1582.                                         MUIA_String_Format,    MUIV_String_Format_Left,
  1583.                                         MUIA_String_BufferPos,    1,
  1584.                                         MUIA_String_Reject,    ":/",
  1585.                                         MUIA_ControlChar,    'v',
  1586.                                     End,
  1587.  
  1588.                         Child, KeyLabel1("Type", 'T'),
  1589.                         Child, ManVolType    =    KeyCycle(TypeEntries, 't'),
  1590.                     End,
  1591.                 End,
  1592.  
  1593.                 Child, VSpace(1),
  1594.  
  1595.                     // Control gadgets
  1596.  
  1597.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1598.  
  1599.                     Child, ManOkObj    =        TextObject, ButtonFrame,
  1600.                                         MUIA_Text_Contents,    "Ok",
  1601.                                         MUIA_Text_PreParse,    "\33c",
  1602.                                         MUIA_Background,    MUII_ButtonBack,
  1603.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1604.                                         MUIA_Text_HiChar,    'O',
  1605.                                         MUIA_ControlChar,    'o',
  1606.                                     End,
  1607.  
  1608.                     Child, ManCancelObj    =    TextObject, ButtonFrame,
  1609.                                         MUIA_Text_Contents,    "Cancel",
  1610.                                         MUIA_Text_PreParse,    "\33c",
  1611.                                         MUIA_Background,    MUII_ButtonBack,
  1612.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1613.                                         MUIA_Text_HiChar,    'C',
  1614.                                         MUIA_ControlChar,    'c',
  1615.                                     End,
  1616.                 End, // Control gadgets
  1617.             End, // Man contents
  1618.         End, // Man window
  1619.     End; // End application
  1620.  
  1621.         // Appobject there and got a list of available entries ???
  1622.  
  1623.     if(AppObject && GetDevVolList(&AvailableList))
  1624.     {
  1625.         struct    VolEntry    *ThisEntry;
  1626.         int            i;
  1627.  
  1628.  
  1629.             // Main window settings
  1630.  
  1631.  
  1632.             // SetCycle chain
  1633.  
  1634.         DoMethod(MainWindow, MUIM_Window_SetCycleChain,
  1635.             UsedList,
  1636.             AvailList,
  1637.             EditEntry,
  1638.             CopyEntry,
  1639.             RemoveEntry,
  1640.             AddEntry,
  1641.             AddEntryMan,
  1642.             RescanList,
  1643.             SaveObj,
  1644.             UseObj,
  1645.             AboutObj,
  1646.             HideObj,
  1647.             QuitObj,
  1648.         NULL);
  1649.  
  1650.             // Set default object
  1651.  
  1652.         set(MainWindow, MUIA_Window_DefaultObject, AvailList);
  1653.  
  1654.             // Set notifications
  1655.  
  1656.         DoMethod(MainWindow, MUIM_Notify,
  1657.             MUIA_Window_CloseRequest,    TRUE,
  1658.             AppObject,            2,
  1659.             MUIM_Application_ReturnID,    ID_HIDE);
  1660.  
  1661.             // Set IDs for gadgets
  1662.  
  1663.         DoMethod(UsedList, MUIM_Notify,
  1664.             MUIA_Listview_DoubleClick,    TRUE,
  1665.             AppObject,            2,
  1666.             MUIM_Application_ReturnID,    ID_USEDLIST);
  1667.  
  1668.         DoMethod(EditEntry, MUIM_Notify,
  1669.             MUIA_Pressed,            FALSE,
  1670.             AppObject,            2,
  1671.             MUIM_Application_ReturnID,    ID_EDITENTRY);
  1672.  
  1673.         DoMethod(CopyEntry, MUIM_Notify,
  1674.             MUIA_Pressed,            FALSE,
  1675.             AppObject,            2,
  1676.             MUIM_Application_ReturnID,    ID_COPYENTRY);
  1677.  
  1678.         DoMethod(RemoveEntry, MUIM_Notify,
  1679.             MUIA_Pressed,            FALSE,
  1680.             AppObject,            2,
  1681.             MUIM_Application_ReturnID,    ID_REMOVEENTRY);
  1682.  
  1683.         DoMethod(AvailList, MUIM_Notify,
  1684.             MUIA_Listview_DoubleClick,    TRUE,
  1685.             AppObject,            2,
  1686.             MUIM_Application_ReturnID,    ID_AVAILLIST);
  1687.  
  1688.         DoMethod(AddEntry, MUIM_Notify,
  1689.             MUIA_Pressed,            FALSE,
  1690.             AppObject,            2,
  1691.             MUIM_Application_ReturnID,    ID_ADDENTRY);
  1692.  
  1693.         DoMethod(AddEntryMan, MUIM_Notify,
  1694.             MUIA_Pressed,            FALSE,
  1695.             AppObject,            2,
  1696.             MUIM_Application_ReturnID,    ID_ADDENTRYMAN);
  1697.  
  1698.         DoMethod(RescanList, MUIM_Notify,
  1699.             MUIA_Pressed,            FALSE,
  1700.             AppObject,            2,
  1701.             MUIM_Application_ReturnID,    ID_RESCANLIST);
  1702.  
  1703.         DoMethod(SaveObj, MUIM_Notify,
  1704.             MUIA_Pressed,            FALSE,
  1705.             AppObject,            2,
  1706.             MUIM_Application_ReturnID,    ID_SAVE);
  1707.  
  1708.         DoMethod(UseObj, MUIM_Notify,
  1709.             MUIA_Pressed,            FALSE,
  1710.             AppObject,            2,
  1711.             MUIM_Application_ReturnID,    ID_USE);
  1712.  
  1713.         DoMethod(AboutObj, MUIM_Notify,
  1714.             MUIA_Pressed,            FALSE,
  1715.             AppObject,            2,
  1716.             MUIM_Application_ReturnID,    ID_ABOUT);
  1717.  
  1718.         DoMethod(HideObj, MUIM_Notify,
  1719.             MUIA_Pressed,            FALSE,
  1720.             AppObject,            2,
  1721.             MUIM_Application_ReturnID,    ID_HIDE);
  1722.  
  1723.         DoMethod(QuitObj, MUIM_Notify,
  1724.             MUIA_Pressed,            FALSE,
  1725.             AppObject,            2,
  1726.             MUIM_Application_ReturnID,    ID_QUIT);
  1727.  
  1728.             // Set disable notify-hooks
  1729.  
  1730.         DoMethod(UsedList, MUIM_Notify,
  1731.             MUIA_List_Active,        MUIV_EveryTime,
  1732.             AppObject,            3,
  1733.             MUIM_CallHook,            &DisableHook, UsedList);
  1734.  
  1735.  
  1736.         DoMethod(AvailList, MUIM_Notify,
  1737.             MUIA_List_Active,        MUIV_EveryTime,
  1738.             AppObject,            3,
  1739.             MUIM_CallHook,            &DisableHook, AvailList);
  1740.  
  1741.  
  1742.  
  1743.             // Edit window settings
  1744.  
  1745.             // Set cycle chain
  1746.  
  1747.         DoMethod(EditWindow, MUIM_Window_SetCycleChain,
  1748.             VolumeName,
  1749.             VolumeType,
  1750.             IconPos[0],
  1751.             IconPos[1],
  1752.             IconX,
  1753.             IconY,
  1754.             Position,
  1755.             UseIcon[0],
  1756.             UseIcon[1],
  1757.             IconName,
  1758.             UseWindow[0],
  1759.             UseWindow[1],
  1760.             WinX,
  1761.             WinY,
  1762.             WinWidth,
  1763.             WinHeight,
  1764.             UseFlags[0],
  1765.             UseFlags[1],
  1766.             FlagModes,
  1767.             EditOkObj,
  1768.             EditCancelObj,
  1769.         NULL);
  1770.  
  1771.  
  1772.             // Set notifications
  1773.  
  1774.         DoMethod(EditWindow, MUIM_Notify,
  1775.             MUIA_Window_CloseRequest,    TRUE,
  1776.             AppObject,            2,
  1777.             MUIM_Application_ReturnID,    ID_EDITCANCEL);
  1778.  
  1779.  
  1780.         DoMethod(EditOkObj, MUIM_Notify,
  1781.             MUIA_Pressed,            FALSE,
  1782.             AppObject,            2,
  1783.             MUIM_Application_ReturnID,    ID_EDITOK);
  1784.  
  1785.  
  1786.         DoMethod(EditCancelObj, MUIM_Notify,
  1787.             MUIA_Pressed,            FALSE,
  1788.             AppObject,            2,
  1789.             MUIM_Application_ReturnID,    ID_EDITCANCEL);
  1790.  
  1791.         DoMethod(Position, MUIM_Notify,
  1792.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1793.             AppObject,            2,
  1794.             MUIM_Application_ReturnID,    ID_POSITION);
  1795.  
  1796.         DoMethod(LookWin, MUIM_Notify,
  1797.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1798.             AppObject,            2,
  1799.             MUIM_Application_ReturnID,    ID_DRAWER);
  1800.  
  1801.         DoMethod(IconX, MUIM_Notify,
  1802.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1803.             AppObject,            2,
  1804.             MUIM_Application_ReturnID,    ID_ICONX);
  1805.  
  1806.         DoMethod(IconY, MUIM_Notify,
  1807.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1808.             AppObject,            2,
  1809.             MUIM_Application_ReturnID,    ID_ICONY);
  1810.  
  1811.         DoMethod(WinX, MUIM_Notify,
  1812.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1813.             AppObject,            2,
  1814.             MUIM_Application_ReturnID,    ID_WINX);
  1815.  
  1816.         DoMethod(WinY, MUIM_Notify,
  1817.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1818.             AppObject,            2,
  1819.             MUIM_Application_ReturnID,    ID_WINY);
  1820.  
  1821.         DoMethod(WinWidth, MUIM_Notify,
  1822.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1823.             AppObject,            2,
  1824.             MUIM_Application_ReturnID,    ID_WINWIDTH);
  1825.  
  1826.         DoMethod(WinHeight, MUIM_Notify,
  1827.             MUIA_String_Acknowledge,    MUIV_EveryTime,
  1828.             AppObject,            2,
  1829.             MUIM_Application_ReturnID,    ID_WINHEIGHT);
  1830.  
  1831.         DoMethod(VolumeType, MUIM_Notify,
  1832.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1833.             IconPosGroup,            3,
  1834.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1835.  
  1836.         DoMethod(VolumeType, MUIM_Notify,
  1837.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1838.             AppObject,            2,
  1839.             MUIM_CallHook, &PageChangeHook);
  1840.  
  1841.  
  1842.  
  1843.         DoMethod(VolumeType, MUIM_Notify,
  1844.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1845.             UseIconGroup,            3,
  1846.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1847.  
  1848.         DoMethod(VolumeType, MUIM_Notify,
  1849.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1850.             UseWindowGroup,            3,
  1851.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1852.  
  1853.         DoMethod(VolumeType, MUIM_Notify,
  1854.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1855.             UseFlagsGroup,            3,
  1856.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1857.  
  1858.  
  1859.         for(i = 0; i < 2; i++)
  1860.         {
  1861.             DoMethod(IconPos[i], MUIM_Notify,
  1862.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1863.                 AppObject,            3,
  1864.                 MUIM_CallHook,            &DisableHook, IconPos[i]);
  1865.  
  1866.  
  1867.             DoMethod(UseIcon[i], MUIM_Notify,
  1868.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1869.                 AppObject,            3,
  1870.                 MUIM_CallHook,            &DisableHook, UseIcon[i]);
  1871.  
  1872.  
  1873.             DoMethod(UseWindow[i], MUIM_Notify,
  1874.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1875.                 AppObject,            3,
  1876.                 MUIM_CallHook,            &DisableHook, UseWindow[i]);
  1877.  
  1878.  
  1879.             DoMethod(UseFlags[i], MUIM_Notify,
  1880.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1881.                 AppObject,            3,
  1882.                 MUIM_CallHook,            &DisableHook, UseFlags[i]);
  1883.         }
  1884.  
  1885.  
  1886.  
  1887.  
  1888.             // Man window settings
  1889.  
  1890.             // Set cycle chaing
  1891.  
  1892.         DoMethod(ManWindow, MUIM_Window_SetCycleChain,
  1893.             ManVolName,
  1894.             ManVolType,
  1895.             ManOkObj,
  1896.             ManCancelObj,
  1897.         NULL);
  1898.  
  1899.  
  1900.             // Set notifications
  1901.  
  1902.         DoMethod(ManWindow, MUIM_Notify,
  1903.             MUIA_Window_CloseRequest,    TRUE,
  1904.             AppObject,            2,
  1905.             MUIM_Application_ReturnID,    ID_MANCANCEL);
  1906.  
  1907.  
  1908.         DoMethod(ManOkObj, MUIM_Notify,
  1909.             MUIA_Pressed,            FALSE,
  1910.             AppObject,            2,
  1911.             MUIM_Application_ReturnID,    ID_MANOK);
  1912.  
  1913.  
  1914.         DoMethod(ManCancelObj, MUIM_Notify,
  1915.             MUIA_Pressed,            FALSE,
  1916.             AppObject,            2,
  1917.             MUIM_Application_ReturnID,    ID_MANCANCEL);
  1918.  
  1919.  
  1920.  
  1921.  
  1922.             // Add list of used entries
  1923.  
  1924.         ObtainSemaphore(&FIconSema->FIconSema);
  1925.         ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  1926.  
  1927.         while(ThisEntry->Link.ln_Succ)
  1928.         {
  1929.             DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  1930.  
  1931.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1932.         }
  1933.         ReleaseSemaphore(&FIconSema->FIconSema);
  1934.  
  1935.  
  1936.             // Add list of available entries
  1937.  
  1938.         ThisEntry    = (struct VolEntry *)AvailableList.lh_Head;
  1939.  
  1940.         while(ThisEntry->Link.ln_Succ)
  1941.         {
  1942.             DoMethod(AvailList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  1943.  
  1944.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1945.         }
  1946.  
  1947.  
  1948.  
  1949.  
  1950.             // Open main window
  1951.  
  1952.         set(MainWindow, MUIA_Window_Open, TRUE);
  1953.     }
  1954.     else
  1955.     {
  1956.         if(MUI_Error() != MUIE_SingleTask)
  1957.             DisplayError(ERR_NO_APP, NULL);
  1958.     }
  1959.  
  1960.  
  1961.     return((BOOL)(AppObject != NULL));
  1962. }
  1963.  
  1964.  
  1965.  
  1966.  
  1967. /**********************************************************************/
  1968. /*                       Remove our application                       */
  1969. /**********************************************************************/
  1970. static void RemoveApp(void)
  1971. {
  1972.     if(AppObject)
  1973.     {
  1974.         set(MainWindow, MUIA_Window_Open, FALSE);
  1975.         MUI_DisposeObject(AppObject);
  1976.     }
  1977.  
  1978.         // Dispose DiskObject
  1979.  
  1980.     if(DObj)
  1981.         FreeDiskObject(DObj);
  1982. }
  1983.  
  1984.  
  1985.  
  1986.  
  1987.  
  1988.  
  1989.  
  1990. /**********************************************************************/
  1991. /*                          Display function                          */
  1992. /**********************************************************************/
  1993. static ULONG    __saveds __asm DispViewFunc(register __a0 struct Hook *MyHook, register __a2 char **array, register __a1 struct VolEntry *Data)
  1994. {
  1995.     static        char    Buffer[140];
  1996.  
  1997.     if(Data->Link.ln_Type == LDF_VOLUMES)
  1998.     {
  1999.         strcpy(Buffer, "\0338");
  2000.         strcat(Buffer, Data->VolName);
  2001.     }
  2002.     else
  2003.         strcpy(Buffer, Data->VolName);
  2004.  
  2005.     *array        = Buffer;
  2006.  
  2007.     return(NULL);
  2008. }
  2009.  
  2010.  
  2011.  
  2012.  
  2013.  
  2014.  
  2015. /**********************************************************************/
  2016. /*                   Hook for setting gadgetstates                    */
  2017. /**********************************************************************/
  2018. static ULONG    __saveds __asm DisableFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data)
  2019. {
  2020.     ULONG    State;
  2021.  
  2022.     if(*Data == UsedList)
  2023.     {
  2024.         get(UsedList, MUIA_List_Active, &State);
  2025.         State    = (State == MUIV_List_Active_Off ? TRUE : FALSE);
  2026.         set(EditEntry, MUIA_Disabled, State);
  2027.         set(CopyEntry, MUIA_Disabled, State);
  2028.         set(RemoveEntry, MUIA_Disabled, State);
  2029.     }
  2030.     else if(*Data == AvailList)
  2031.     {
  2032.         get(AvailList, MUIA_List_Active, &State);
  2033.         State    = (State == MUIV_List_Active_Off ? TRUE : FALSE);
  2034.         set(AddEntry, MUIA_Disabled, State);
  2035.     }
  2036.     else if((*Data == IconPos[0]) || (*Data == IconPos[1]))
  2037.     {
  2038.         get(*Data, MUIA_Cycle_Active, &State);
  2039.         set(IconX, MUIA_Disabled, (State != MODE_USE));
  2040.         set(IconY, MUIA_Disabled, (State != MODE_USE));
  2041.         set(Position, MUIA_Disabled, (State != MODE_USE));
  2042.     }
  2043.     else if((*Data == UseIcon[0]) || (*Data == UseIcon[1]))
  2044.     {
  2045.         get(*Data, MUIA_Cycle_Active, &State);
  2046.         set(IconName, MUIA_Disabled, (State != MODE_USE));
  2047.     }
  2048.     else if((*Data == UseWindow[0]) || (*Data == UseWindow[1]))
  2049.     {
  2050.         get(*Data, MUIA_Cycle_Active, &State);
  2051.         set(WinX, MUIA_Disabled, (State != MODE_USE));
  2052.         set(WinY, MUIA_Disabled, (State != MODE_USE));
  2053.         set(WinWidth, MUIA_Disabled, (State != MODE_USE));
  2054.         set(WinHeight, MUIA_Disabled, (State != MODE_USE));
  2055.         set(LookWin, MUIA_Disabled, (State != MODE_USE));
  2056.     }
  2057.     else if((*Data == UseFlags[0]) || (*Data == UseFlags[1]))
  2058.     {
  2059.         get(*Data, MUIA_Cycle_Active, &State);
  2060.         set(FlagModes, MUIA_Disabled, (State != MODE_USE));
  2061.     }
  2062.  
  2063.     return(0);
  2064. }
  2065.  
  2066.  
  2067.  
  2068.  
  2069.  
  2070.  
  2071. /**********************************************************************/
  2072. /*   Change gadget states on settings of cycle gadget (VolumeType)    */
  2073. /**********************************************************************/
  2074. static ULONG    __saveds __asm PageChangeFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data)
  2075. {
  2076.     ULONG    Page;
  2077.     ULONG    State;
  2078.  
  2079.         // Get current page
  2080.  
  2081.     get(VolumeType, MUIA_Cycle_Active, &Page);
  2082.  
  2083.         // Set gadget states
  2084.  
  2085.     get(IconPos[Page], MUIA_Cycle_Active, &State);
  2086.     set(IconX, MUIA_Disabled, (State != MODE_USE));
  2087.     set(IconY, MUIA_Disabled, (State != MODE_USE));
  2088.     set(Position, MUIA_Disabled, (State != MODE_USE));
  2089.  
  2090.     get(UseIcon[Page], MUIA_Cycle_Active, &State);
  2091.     set(IconName, MUIA_Disabled, (State != MODE_USE));
  2092.  
  2093.     get(UseWindow[Page], MUIA_Cycle_Active, &State);
  2094.     set(WinX, MUIA_Disabled, (State != MODE_USE));
  2095.     set(WinY, MUIA_Disabled, (State != MODE_USE));
  2096.     set(WinWidth, MUIA_Disabled, (State != MODE_USE));
  2097.     set(WinHeight, MUIA_Disabled, (State != MODE_USE));
  2098.     set(LookWin, MUIA_Disabled, (State != MODE_USE));
  2099.  
  2100.     get(UseFlags[Page], MUIA_Cycle_Active, &State);
  2101.     set(FlagModes, MUIA_Disabled, (State != MODE_USE));
  2102.  
  2103.     return(0);
  2104. }
  2105.  
  2106.  
  2107.  
  2108.  
  2109.  
  2110.  
  2111.  
  2112.  
  2113.  
  2114.  
  2115.  
  2116.  
  2117. /**********************************************************************/
  2118. /*             Add a new volumes/device to the used list              */
  2119. /**********************************************************************/
  2120. static struct VolEntry *AddNewVolume(char *Name, ULONG Type, struct VolEntry *CopyPtr)
  2121. {
  2122.     struct    VolEntry    *NewEntry    = NULL,
  2123.                 *ThisEntry;
  2124.  
  2125.         // Check for exitance
  2126.  
  2127.     if(CheckExists(Name))
  2128.     {
  2129.         DisplayError(ERR_EXISTS, (ULONG)Name);
  2130.         return(NewEntry);
  2131.     }
  2132.  
  2133.         // Try to get our semaphore
  2134.  
  2135.     ObtainSemaphore(&FIconSema->FIconSema);
  2136.  
  2137.         // Get memory for new entry
  2138.  
  2139.     if((NewEntry = AllocVecPool(FIconSema, sizeof(struct VolEntry))))
  2140.     {
  2141.             // One entry plus
  2142.  
  2143.         FIconSema->VolumeList.lh_Type++;
  2144.  
  2145.             // Add entry and fill out structure
  2146.  
  2147.         if(Type == LDF_VOLUMES)
  2148.             AddHead(&FIconSema->VolumeList, (struct Node *)NewEntry);
  2149.         else
  2150.             AddTail(&FIconSema->VolumeList, (struct Node *)NewEntry);
  2151.  
  2152.         NewEntry->Link.ln_Name    = NewEntry->VolName;
  2153.         NewEntry->Link.ln_Type    = Type;
  2154.         strcpy(NewEntry->VolName, Name);
  2155.  
  2156.             // Copy contents of other entry ???
  2157.  
  2158.         if(CopyPtr)
  2159.         {
  2160.             strcpy(NewEntry->IconName, CopyPtr->IconName);
  2161.             NewEntry->Left        = CopyPtr->Left;
  2162.             NewEntry->Top        = CopyPtr->Top;
  2163.             NewEntry->IconPos    = CopyPtr->IconPos;
  2164.             NewEntry->UseAlt    = CopyPtr->UseAlt;
  2165.             NewEntry->UseWin    = CopyPtr->UseWin;
  2166.             NewEntry->WinX        = CopyPtr->WinX;
  2167.             NewEntry->WinY        = CopyPtr->WinY;
  2168.             NewEntry->WinWidth    = CopyPtr->WinWidth;
  2169.             NewEntry->WinHeight    = CopyPtr->WinHeight;
  2170.             NewEntry->UseFlags    = CopyPtr->UseFlags;
  2171.             NewEntry->WinFlags    = CopyPtr->WinFlags;
  2172.         }
  2173.  
  2174.             // Remove entries from listview (Used)
  2175.  
  2176.         DoMethod(UsedList, MUIM_List_Clear, NULL);
  2177.  
  2178.             // Sort the list again
  2179.  
  2180.         SortList(&FIconSema->VolumeList, TRUE);
  2181.  
  2182.             // Readd list
  2183.  
  2184.         ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2185.         while(ThisEntry->Link.ln_Succ)
  2186.         {
  2187.             DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  2188.  
  2189.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2190.         }
  2191.     }
  2192.     else
  2193.     {
  2194.         DisplayError(ERR_NOMEM, NULL);
  2195.         NewEntry    = NULL;
  2196.     }
  2197.  
  2198.         // Free our semaphore
  2199.  
  2200.     ReleaseSemaphore(&FIconSema->FIconSema);
  2201.  
  2202.     return(NewEntry);
  2203. }
  2204.  
  2205.  
  2206.  
  2207.  
  2208.  
  2209.  
  2210.  
  2211.  
  2212. /**********************************************************************/
  2213. /*        Check for existance of a volume within the user list        */
  2214. /**********************************************************************/
  2215. static BOOL CheckExists(char *Name)
  2216. {
  2217.     BOOL    RetVal = FALSE;
  2218.  
  2219.     ObtainSemaphore(&FIconSema->FIconSema);
  2220.  
  2221.     if(!IsListEmpty(&FIconSema->VolumeList))
  2222.     {
  2223.         struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2224.  
  2225.         do
  2226.         {
  2227.             if(!stricmp(ThisEntry->VolName, Name))
  2228.                 RetVal = TRUE;
  2229.  
  2230.             ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2231.         } while(!RetVal && ThisEntry->Link.ln_Succ);
  2232.     }
  2233.  
  2234.     ReleaseSemaphore(&FIconSema->FIconSema);
  2235.  
  2236.     return(RetVal);
  2237. }
  2238.  
  2239.  
  2240.  
  2241.  
  2242.  
  2243.  
  2244.  
  2245. /**********************************************************************/
  2246. /*                       Save Prefs to disk/env                       */
  2247. /**********************************************************************/
  2248. static BOOL            DoSavePrefs(char *PrefsName);
  2249. static BOOL SavePrefs(BOOL EnvMode)
  2250. {
  2251.         // On ENV: mode, simply save to ENV: only
  2252.  
  2253.     if(DoSavePrefs("ENV:ForceIcon_prefs.iff"))
  2254.     {
  2255.             // Otherwise write to envarc: as well
  2256.  
  2257.         if(!EnvMode)
  2258.             return(DoSavePrefs("ENVARC:ForceIcon_prefs.iff"));
  2259.         else
  2260.             return(TRUE);
  2261.     }
  2262.     return(FALSE);
  2263. }
  2264. static BOOL DoSavePrefs(char *PrefsName)
  2265. {
  2266.     struct    IFFHandle    *PrefsHandle;
  2267.     LONG    Error;
  2268.     BOOL    GoOn = FALSE;
  2269.     UWORD    VersChunk[] =
  2270.     {
  2271.         VERNUM,
  2272.         REVNUM
  2273.     };
  2274.  
  2275.  
  2276.     ObtainSemaphore(&FIconSema->FIconSema);
  2277.  
  2278.         // Get handle for IFF
  2279.  
  2280.     if((PrefsHandle = AllocIFF()))
  2281.     {
  2282.             // Open file for save
  2283.  
  2284.         if((PrefsHandle->iff_Stream = Open(PrefsName, MODE_NEWFILE)))
  2285.         {
  2286.                 // Init Handle
  2287.  
  2288.             InitIFFasDOS(PrefsHandle);
  2289.  
  2290.                 // Open Handle
  2291.  
  2292.             if(!(Error = OpenIFF(PrefsHandle, IFFF_WRITE)))
  2293.             {
  2294.                     // Write FORM chunk
  2295.  
  2296.                 if(!(Error = PushChunk(PrefsHandle, 'FOIC', 'FORM', IFFSIZE_UNKNOWN)))
  2297.                 {
  2298.                         // Write version chunk
  2299.  
  2300.                     if(!(Error = PushChunk(PrefsHandle, 'FOIC', 'VERS', IFFSIZE_UNKNOWN)))
  2301.                     {
  2302.                         if((Error = WriteChunkBytes(PrefsHandle, &VersChunk[0], (sizeof(UWORD) * 2))) == (sizeof(UWORD) * 2))
  2303.                             Error = PopChunk(PrefsHandle);
  2304.                         else
  2305.                             Error = IoErr();
  2306.                     }
  2307.  
  2308.                         // Write Prefs chunk
  2309.  
  2310.                     if(!Error && !(Error = PushChunk(PrefsHandle, 'FOIC', 'PREF', IFFSIZE_UNKNOWN)))
  2311.                     {
  2312.                         struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2313.                         UWORD    NumEntries            = FIconSema->VolumeList.lh_Type;
  2314.                         BOOL    NoErr = TRUE;
  2315.  
  2316.                                 // Write all entries of volume list
  2317.  
  2318.                         if((Error = WriteChunkBytes(PrefsHandle, &NumEntries, sizeof(UWORD))) == sizeof(UWORD))
  2319.                         {
  2320.                             while(NumEntries-- && NoErr)
  2321.                             {
  2322.                                 UWORD    EntryType = ThisEntry->Link.ln_Type;
  2323.  
  2324.                                 if((Error = WriteChunkBytes(PrefsHandle, &EntryType, sizeof(UWORD))) == sizeof(UWORD))
  2325.                                 {
  2326.                                     if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->VolName, 130)) == 130)
  2327.                                     {
  2328.                                         if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->IconName, 256)) == 256)
  2329.                                         {
  2330.                                             if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->Left, (sizeof(UWORD) * 36))) != (sizeof(UWORD) * 36))
  2331.                                                 NoErr = FALSE;
  2332.                                         }
  2333.                                     }
  2334.                                 }
  2335.  
  2336.                                 ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2337.                             }
  2338.  
  2339.                             if(NoErr)
  2340.                             {
  2341.                                 if(!(Error = PopChunk(PrefsHandle)))
  2342.                                     GoOn = TRUE;
  2343.                             }
  2344.                         }
  2345.                     }
  2346.                 }
  2347.  
  2348.                 if((Error = PopChunk(PrefsHandle)))
  2349.                     GoOn = FALSE;
  2350.  
  2351.                 CloseIFF(PrefsHandle);
  2352.             }
  2353.  
  2354.             Close(PrefsHandle->iff_Stream);
  2355.         }
  2356.         else
  2357.             Error = IoErr();
  2358.  
  2359.         FreeIFF(PrefsHandle);
  2360.     }
  2361.     else
  2362.         Error = ERR_NOMEM;
  2363.  
  2364.     if(!GoOn)
  2365.         DisplayError(Error, (ULONG)PrefsName);
  2366.  
  2367.     ReleaseSemaphore(&FIconSema->FIconSema);
  2368.  
  2369.     return(GoOn);
  2370. }
  2371.  
  2372.  
  2373.  
  2374.  
  2375.  
  2376. /**********************************************************************/
  2377. /*                  Make a specific entry diskchange                  */
  2378. /**********************************************************************/
  2379. static void DskChange(struct VolEntry *ListEntry)
  2380. {
  2381.     struct    List    ChangeList;
  2382.  
  2383.     NewList(&ChangeList);
  2384.  
  2385.  
  2386.         // Create list of connected devices
  2387.  
  2388.     if(GetDosEntries(&ChangeList, LDF_VOLUMES))
  2389.     {
  2390.         struct    DosList        *DList;
  2391.         struct    VolEntry    *ThisEntry;
  2392.         struct    DevProc        *DevProc;
  2393.         char            DevName[130];
  2394.         BOOL            FoundDev,
  2395.                     DoDskCh;
  2396.  
  2397.             // Loop for all volumes in list
  2398.  
  2399.         while((ThisEntry = (struct VolEntry *)RemHead(&ChangeList)))
  2400.         {
  2401.             FoundDev    = FALSE;
  2402.  
  2403.                 // Find name of device this volume resides in
  2404.  
  2405.             if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  2406.             {
  2407.                 while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  2408.                 {
  2409.                     if(ThisEntry->DriverTask == DList->dol_Task)
  2410.                     {
  2411.                         setmem(DevName, 130, 0);
  2412.                         strncpy(DevName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  2413.                         FoundDev    = TRUE;
  2414.                     }
  2415.                 }
  2416.                 UnLockDosList(LDF_DEVICES|LDF_READ);
  2417.             }
  2418.  
  2419.                 // Found corresponding device ???
  2420.  
  2421.             if(FoundDev)
  2422.             {
  2423.                     // Check whether to diskchange
  2424.  
  2425.                 if(ListEntry->Link.ln_Type == LDF_DEVICES)
  2426.                     DoDskCh    = (MyStrCmp(ListEntry->VolName, DevName) == 0);
  2427.                 else
  2428.                     DoDskCh    = (MyStrCmp(ListEntry->VolName, ThisEntry->VolName) == 0);
  2429.  
  2430.                     // Diskchange device ???
  2431.  
  2432.                 if(DoDskCh)
  2433.                 {
  2434.                     strcat(DevName, ":");
  2435.  
  2436.                     if(ThisEntry->DriverTask && (DevProc = GetDeviceProc(DevName, NULL)))
  2437.                     {
  2438.                         if(TypeOfMem(DevProc->dvp_Port))
  2439.                         {
  2440.                             if(DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSTRUE, NULL, NULL, NULL, NULL))
  2441.                                 DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSFALSE, NULL, NULL, NULL, NULL);
  2442.                         }
  2443.                         FreeDeviceProc(DevProc);
  2444.                     }
  2445.                 }
  2446.             }
  2447.  
  2448.             FreeVecPool(FIconSema, ThisEntry);
  2449.         }
  2450.     }
  2451. }
  2452.  
  2453.  
  2454.  
  2455.  
  2456.  
  2457.  
  2458. /**********************************************************************/
  2459. /*       Now include the LoadRoutine and the VolumeList routine       */
  2460. /**********************************************************************/
  2461. #include    "LoadPrefs.h"
  2462. #include    "VolList.h"
  2463. #include    "Error.h"
  2464. #include    "Rendezvous.h"
  2465. #include    "CheckToolTypes.h"
  2466. #include    "PoolVec.h"
  2467.